package algorithm;

import java.util.ArrayList;

import structure.production;

public class miscellaneous {
	
	public miscellaneous(){
		
	}
	
	//crea le combinazioni della stringa passata
	public static ArrayList<String> combine(String paramS){
		
		ArrayList<String> single= new ArrayList<String>();
		ArrayList<String> combined= new ArrayList<String>();
		
		//inserisco la stringa intera ad esempio 1,3,5
		combined.add(paramS + ",");
		
		//inserisco i termini singoli
		for(char c : paramS.toCharArray()){
			
			if(c != ','){
				String str= Character.toString(c);
				single.add(str);
				if(!combined.contains(str)) {
	
					combined.add(str + ",");
				}
			}
		}
		
		//combino i singoli
		int start=0, end=0;
		for(String s : single){
			
			singleCombine(start, end, single, combined);
			start++;
		}
		
		return combined;
	}
	
	//crea le singole combinazioni di supporto a combine
	public static void singleCombine(int start, int end, ArrayList<String> single, ArrayList<String> combined){
		
		if(end<single.size()){
			//creo la parte statica della combinazione di caratteri
			String A= "";
			for(int j=start; j<=end; j++){
				
				A+= single.get(j) + ",";
			}
			//aggiungo la parte dinamica
			for(int i=end+1; i<single.size(); i++){
				
				String o= A + single.get(i) + ",";
				if(!combined.contains(o)){
					
					combined.add(o);
				}
			}
			end++;
			//richiamo ricorsivamente la funzione per cambiare livello di profondità nelle combinazioni
			singleCombine(start, end, single, combined);
		}
	}

	public static int getPositionOfString(ArrayList<String> array, String s){
		
		for(int i=0; i<array.size(); i++){
			
			if(s.equals(array.get(i))){
				
				return i;
			}
		}
		
		return -1;
	}
	
	//clona una array di produzioni
	public static ArrayList<production> cloneArray(ArrayList<production> toClone){
		
		ArrayList<production> toReturn= new ArrayList<production>();
		for(production p : toClone){
			
			try {
				toReturn.add((production) p.clone());
			} catch (CloneNotSupportedException e) {
				e.printStackTrace();
			}
		}
		return toReturn;
	}
	
	//calcola il massimo di due interi
	public static int getMax(int a, int b){
		
		if(a>b) return a;
		
		return b;
	}
	
	//controlla se la produzione esiste già in un array di produzioni
	public static boolean productionAlreadyExist(ArrayList<production> productions, String production){
		
		for(production p : productions){
			
			if(p.contain(production)) return true;
		}
		
		return false;
	}
	
	//controlla se il carattere passato è un numero
	public static boolean isANumber(char c){
		
		char[] numbers= {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};
		for(char f : numbers){
			
			if(c == f)
				return true;
		}
		
		return false;
	}
	
	public static void removeStringFromArray(ArrayList<String> array){
		
		String toRemove= "";
		for(String s : array){
			
			char[] tmpC= s.toCharArray();
			for(int i=0; i<tmpC.length-1; i++){
				if(isANumber(tmpC[i+1]))
					toRemove= Character.toString(tmpC[i]);
			}
		}
		
		int position= getPositionOfString(array, toRemove);
		if(position > 0)
			array.remove(position);
	}
	
	//splitta una stringa in due parti in base alle dimensioni e alla posizione dei numeri
	public static String[] splitItByNumbers(String toSplit){
		
		String[] toReturn= new String[2];
		//da fare i 4 casi A->BC A->A1B A->BA1 A->A1A2
		int size= toSplit.length();
		if(size == 2){
			//caso A->BC
			toReturn[0]= toSplit.substring(0, 1);
			toReturn[1]= toSplit.substring(1, 2);
		}
		else if(size == 3){
			//caso A->BA0 o A->A0B
			String first= toSplit.substring(0, 1);
			String middle= toSplit.substring(1, 2);
			String last= toSplit.substring(2);//da controllare
			
			if(miscellaneous.isANumber(middle.charAt(0))){
				//A->A0B
				toReturn[0]= first + middle;
				toReturn[1]= last;
			}
			else if(miscellaneous.isANumber(last.charAt(0))){
				//A->BA0
				toReturn[0]= first;
				toReturn[1]= middle + last;
			}
			else{
				//System.out.println("ERROR in splitItByNumbers, string size = 3, not in allowed form.");
			}
		}
		else if(size == 4){
			//caso A->A0A1
			toReturn[0]= toSplit.substring(0, 2);
			toReturn[1]= toSplit.substring(2);
		}
		else{
			//System.out.println("ERROR in splitItByNumbers, not in allowed form.");
		}
		
		return toReturn;
	}
}
